/*
 * Copyright 2010 Thedwick, LLC

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

 */
package com.thedwick.jdbcGrabber.resultset;

import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.NClob;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.RowId;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.SQLXML;
import java.sql.Statement;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.Calendar;
import java.util.Map;

import com.thedwick.jdbcGrabber.sink.SQLSink;

public class gbResultSet implements ResultSet {
	private final ResultSet underlying;
	private final SQLSink sink;
	
	public gbResultSet(ResultSet underlying, SQLSink sink){
		this.underlying = underlying;
		this.sink = sink;
	}
	
	@Override
	public boolean absolute(int row) throws SQLException {
		return this.underlying.absolute(row);
	}

	@Override
	public void afterLast() throws SQLException {
		this.underlying.afterLast();

	}

	@Override
	public void beforeFirst() throws SQLException {
		this.underlying.beforeFirst();
	}

	@Override
	public void cancelRowUpdates() throws SQLException {
		this.underlying.cancelRowUpdates();
	}

	@Override
	public void clearWarnings() throws SQLException {
		this.underlying.clearWarnings();
	}

	@Override
	public void close() throws SQLException {
		this.underlying.close();
	}

	@Override
	public void deleteRow() throws SQLException {
		this.underlying.deleteRow();
	}

	@Override
	public int findColumn(String columnName) throws SQLException {
		return this.underlying.findColumn(columnName);
	}

	@Override
	public boolean first() throws SQLException {
		return this.underlying.first();
	}

	@Override
	public Array getArray(int i) throws SQLException {
		return this.underlying.getArray(i);
	}

	@Override
	public Array getArray(String colName) throws SQLException {
		return this.underlying.getArray(colName);
	}

	@Override
	public InputStream getAsciiStream(int columnIndex) throws SQLException {
		return this.underlying.getAsciiStream(columnIndex);
	}

	@Override
	public InputStream getAsciiStream(String columnName) throws SQLException {
		return this.underlying.getAsciiStream(columnName);
	}

	@Override
	public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
		return this.underlying.getBigDecimal(columnIndex);
	}

	@Override
	public BigDecimal getBigDecimal(String columnName) throws SQLException {
		return this.underlying.getBigDecimal(columnName);
	}

	@Override
	public BigDecimal getBigDecimal(int columnIndex, int scale)
			throws SQLException {
		return this.underlying.getBigDecimal(columnIndex, scale)
		;
	}

	@Override
	public BigDecimal getBigDecimal(String columnName, int scale)
			throws SQLException {
		return this.underlying.getBigDecimal(columnName, scale);
	}

	@Override
	public InputStream getBinaryStream(int columnIndex) throws SQLException {
		return this.underlying.getBinaryStream(columnIndex);
	}

	@Override
	public InputStream getBinaryStream(String columnName) throws SQLException {
		return this.underlying.getBinaryStream(columnName);
	}

	@Override
	public Blob getBlob(int i) throws SQLException {
		return this.underlying.getBlob(i);
	}

	@Override
	public Blob getBlob(String colName) throws SQLException {
		return this.underlying.getBlob(colName);
	}

	@Override
	public boolean getBoolean(int columnIndex) throws SQLException {
		return this.underlying.getBoolean(columnIndex);
	}

	@Override
	public boolean getBoolean(String columnName) throws SQLException {
		return this.underlying.getBoolean(columnName);
	}

	@Override
	public byte getByte(int columnIndex) throws SQLException {
		return this.underlying.getByte(columnIndex);
	}

	@Override
	public byte getByte(String columnName) throws SQLException {
		return this.underlying.getByte(columnName);
	}

	@Override
	public byte[] getBytes(int columnIndex) throws SQLException {
		return this.underlying.getBytes(columnIndex);
	}

	@Override
	public byte[] getBytes(String columnName) throws SQLException {
		return this.underlying.getBytes(columnName);
	}

	@Override
	public Reader getCharacterStream(int columnIndex) throws SQLException {
		return this.underlying.getCharacterStream(columnIndex);
	}

	@Override
	public Reader getCharacterStream(String columnName) throws SQLException {
		return this.underlying.getCharacterStream(columnName);
	}

	@Override
	public Clob getClob(int i) throws SQLException {
		return this.underlying.getClob(i);
	}

	@Override
	public Clob getClob(String colName) throws SQLException {
		return this.underlying.getClob(colName);
	}

	@Override
	public int getConcurrency() throws SQLException {
		return this.underlying.getConcurrency();
	}

	@Override
	public String getCursorName() throws SQLException {
		return this.underlying.getCursorName();
	}

	@Override
	public Date getDate(int columnIndex) throws SQLException {
		return this.underlying.getDate(columnIndex);
	}

	@Override
	public Date getDate(String columnName) throws SQLException {
		return this.underlying.getDate(columnName);
	}

	@Override
	public Date getDate(int columnIndex, Calendar cal) throws SQLException {
		return this.underlying.getDate(columnIndex,cal);
	}

	@Override
	public Date getDate(String columnName, Calendar cal) throws SQLException {
		return this.underlying.getDate(columnName, cal);
	}

	@Override
	public double getDouble(int columnIndex) throws SQLException {
		return this.underlying.getDouble(columnIndex);
	}

	@Override
	public double getDouble(String columnName) throws SQLException {
		return this.underlying.getDouble(columnName);
	}

	@Override
	public int getFetchDirection() throws SQLException {
		return this.underlying.getFetchDirection();
	}

	@Override
	public int getFetchSize() throws SQLException {
		return this.underlying.getFetchSize();
	}

	@Override
	public float getFloat(int columnIndex) throws SQLException {
		return this.underlying.getFloat(columnIndex);
	}

	@Override
	public float getFloat(String columnName) throws SQLException {
		return this.underlying.getFloat(columnName);
	}

	@Override
	public int getHoldability() throws SQLException {
		return this.underlying.getHoldability();
	}

	@Override
	public int getInt(int columnIndex) throws SQLException {
		return this.underlying.getInt(columnIndex);
	}

	@Override
	public int getInt(String columnName) throws SQLException {
		return this.underlying.getInt(columnName);
	}

	@Override
	public long getLong(int columnIndex) throws SQLException {
		return this.underlying.getLong(columnIndex);
	}

	@Override
	public long getLong(String columnName) throws SQLException {
		return this.underlying.getLong(columnName);
	}

	@Override
	public ResultSetMetaData getMetaData() throws SQLException {
		return this.underlying.getMetaData();
	}

	@Override
	public Reader getNCharacterStream(int arg0) throws SQLException {
		return this.underlying.getNCharacterStream(arg0);
	}

	@Override
	public Reader getNCharacterStream(String arg0) throws SQLException {
		return this.underlying.getNCharacterStream(arg0);
	}

	@Override
	public NClob getNClob(int arg0) throws SQLException {
		return this.underlying.getNClob(arg0);
	}

	@Override
	public NClob getNClob(String arg0) throws SQLException {
		return this.underlying.getNClob(arg0);
	}

	@Override
	public String getNString(int arg0) throws SQLException {
		return this.underlying.getNString(arg0);
	}

	@Override
	public String getNString(String arg0) throws SQLException {
		return this.underlying.getNString(arg0);
	}

	@Override
	public Object getObject(int columnIndex) throws SQLException {
		return this.underlying.getObject(columnIndex);
	}

	@Override
	public Object getObject(String columnName) throws SQLException {
		return this.underlying.getObject(columnName);
	}

	@Override
	public Object getObject(int i, Map<String, Class<?>> map)
			throws SQLException {
		return this.underlying.getObject(i, map);
	}

	@Override
	public Object getObject(String colName, Map<String, Class<?>> map)
			throws SQLException {
		return this.underlying.getObject(colName, map);
	}

	@Override
	public Ref getRef(int i) throws SQLException {

		return this.underlying.getRef(i);
	}

	@Override
	public Ref getRef(String colName) throws SQLException {

		return this.underlying.getRef(colName);
	}

	@Override
	public int getRow() throws SQLException {
		return this.underlying.getRow();
	}

	@Override
	public RowId getRowId(int arg0) throws SQLException {

		return this.underlying.getRowId(arg0);
	}

	@Override
	public RowId getRowId(String arg0) throws SQLException {

		return this.underlying.getRowId(arg0);
	}

	@Override
	public SQLXML getSQLXML(int arg0) throws SQLException {

		return this.underlying.getSQLXML(arg0);
	}

	@Override
	public SQLXML getSQLXML(String arg0) throws SQLException {

		return this.underlying.getSQLXML(arg0);
	}

	@Override
	public short getShort(int columnIndex) throws SQLException {

		return this.underlying.getShort(columnIndex);
	}

	@Override
	public short getShort(String columnName) throws SQLException {

		return this.underlying.getShort(columnName);
	}

	@Override
	public Statement getStatement() throws SQLException {

		return this.underlying.getStatement();
	}

	@Override
	public String getString(int columnIndex) throws SQLException {

		return this.underlying.getString(columnIndex);
	}

	@Override
	public String getString(String columnName) throws SQLException {

		return this.underlying.getString(columnName);
	}

	@Override
	public Time getTime(int columnIndex) throws SQLException {

		return this.underlying.getTime(columnIndex);
	}

	@Override
	public Time getTime(String columnName) throws SQLException {

		return this.underlying.getTime(columnName);
	}

	@Override
	public Time getTime(int columnIndex, Calendar cal) throws SQLException {

		return this.underlying.getTime(columnIndex, cal);
	}

	@Override
	public Time getTime(String columnName, Calendar cal) throws SQLException {

		return this.underlying.getTime(columnName, cal);
	}

	@Override
	public Timestamp getTimestamp(int columnIndex) throws SQLException {

		return this.underlying.getTimestamp(columnIndex);
	}

	@Override
	public Timestamp getTimestamp(String columnName) throws SQLException {

		return this.underlying.getTimestamp(columnName);
	}

	@Override
	public Timestamp getTimestamp(int columnIndex, Calendar cal)
			throws SQLException {

		return this.underlying.getTimestamp(columnIndex, cal);
	}

	@Override
	public Timestamp getTimestamp(String columnName, Calendar cal)
			throws SQLException {

		return this.underlying.getTimestamp(columnName, cal);
	}

	@Override
	public int getType() throws SQLException {

		return this.underlying.getType();
	}

	@Override
	public URL getURL(int columnIndex) throws SQLException {

		return this.underlying.getURL(columnIndex);
	}

	@Override
	public URL getURL(String columnName) throws SQLException {

		return this.underlying.getURL(columnName);
	}

	@Override
	public InputStream getUnicodeStream(int columnIndex) throws SQLException {

		return this.underlying.getUnicodeStream(columnIndex);
	}

	@Override
	public InputStream getUnicodeStream(String columnName) throws SQLException {

		return this.underlying.getUnicodeStream(columnName);
	}

	@Override
	public SQLWarning getWarnings() throws SQLException {

		return this.underlying.getWarnings();
	}

	@Override
	public void insertRow() throws SQLException {
		this.underlying.insertRow();
	}

	@Override
	public boolean isAfterLast() throws SQLException {
		return this.underlying.isAfterLast();
	}

	@Override
	public boolean isBeforeFirst() throws SQLException {

		return this.underlying.isBeforeFirst();
	}

	@Override
	public boolean isClosed() throws SQLException {

		return this.underlying.isClosed();
	}

	@Override
	public boolean isFirst() throws SQLException {

		return this.underlying.isFirst();
	}

	@Override
	public boolean isLast() throws SQLException {

		return this.underlying.isLast();
	}

	@Override
	public boolean last() throws SQLException {

		return this.underlying.last();
	}

	@Override
	public void moveToCurrentRow() throws SQLException {
		this.underlying.moveToCurrentRow();


	}

	@Override
	public void moveToInsertRow() throws SQLException {
		this.underlying.moveToInsertRow();

	}

	@Override
	public boolean next() throws SQLException {
		return this.underlying.next();
	}

	@Override
	public boolean previous() throws SQLException {
		return this.underlying.previous();
	}

	@Override
	public void refreshRow() throws SQLException {
		this.underlying.refreshRow();
	}

	@Override
	public boolean relative(int rows) throws SQLException {

		return this.underlying.relative(rows);
	}

	@Override
	public boolean rowDeleted() throws SQLException {

		return this.underlying.rowDeleted();
	}

	@Override
	public boolean rowInserted() throws SQLException {

		return this.underlying.rowInserted();
	}

	@Override
	public boolean rowUpdated() throws SQLException {

		return this.underlying.rowUpdated();
	}

	@Override
	public void setFetchDirection(int direction) throws SQLException {
		this.underlying.setFetchDirection(direction);
	}

	@Override
	public void setFetchSize(int rows) throws SQLException {
		this.underlying.setFetchSize(rows);
	}

	@Override
	public void updateArray(int columnIndex, Array x) throws SQLException {
		this.underlying.updateArray(columnIndex, x)
		;
	}

	@Override
	public void updateArray(String columnName, Array x) throws SQLException {
		this.underlying.updateArray(columnName, x);
	}

	@Override
	public void updateAsciiStream(int arg0, InputStream arg1)
			throws SQLException {
		this.underlying.updateAsciiStream(arg0, arg1);
	}

	@Override
	public void updateAsciiStream(String arg0, InputStream arg1)
			throws SQLException {
		this.underlying.updateAsciiStream(arg0, arg1);
	}

	@Override
	public void updateAsciiStream(int columnIndex, InputStream x, int length)
			throws SQLException {
		this.underlying.updateAsciiStream(columnIndex, x, length);
	}

	@Override
	public void updateAsciiStream(String columnName, InputStream x, int length)
			throws SQLException {
		this.underlying.updateAsciiStream(columnName, x, length);
	}

	@Override
	public void updateAsciiStream(int arg0, InputStream arg1, long arg2)
			throws SQLException {
		this.underlying.updateAsciiStream(arg0, arg1, arg2);
	}

	@Override
	public void updateAsciiStream(String arg0, InputStream arg1, long arg2)
			throws SQLException {
		this.underlying.updateAsciiStream(arg0, arg1, arg2);
	}

	@Override
	public void updateBigDecimal(int columnIndex, BigDecimal x)
			throws SQLException {
		this.underlying.updateBigDecimal(columnIndex, x);
	}

	@Override
	public void updateBigDecimal(String columnName, BigDecimal x)
			throws SQLException {
		this.underlying.updateBigDecimal(columnName, x);
	}

	@Override
	public void updateBinaryStream(int arg0, InputStream arg1)
			throws SQLException {
		this.underlying.updateBinaryStream(arg0, arg1);
	}

	@Override
	public void updateBinaryStream(String arg0, InputStream arg1)
			throws SQLException {
		this.underlying.updateBinaryStream(arg0, arg1);
	}

	@Override
	public void updateBinaryStream(int columnIndex, InputStream x, int length)
			throws SQLException {
		this.underlying.updateBinaryStream(columnIndex,x,length);
	}

	@Override
	public void updateBinaryStream(String columnName, InputStream x, int length)
			throws SQLException {
		this.underlying.updateBinaryStream(columnName, x, length);
	}

	@Override
	public void updateBinaryStream(int arg0, InputStream arg1, long arg2)
			throws SQLException {
		this.underlying.updateBinaryStream(arg0, arg1, arg2);
	}

	@Override
	public void updateBinaryStream(String arg0, InputStream arg1, long arg2)
			throws SQLException {
		this.underlying.updateBinaryStream(arg0, arg1,arg2);
	}

	@Override
	public void updateBlob(int columnIndex, Blob x) throws SQLException {
		this.underlying.updateBlob(columnIndex, x);
	}

	@Override
	public void updateBlob(String columnName, Blob x) throws SQLException {
		this.underlying.updateBlob(columnName, x);
	}

	@Override
	public void updateBlob(int arg0, InputStream arg1) throws SQLException {
		this.underlying.updateBlob(arg0,arg1);
	}

	@Override
	public void updateBlob(String arg0, InputStream arg1) throws SQLException {
		this.underlying.updateBlob(arg0, arg1);
	}

	@Override
	public void updateBlob(int arg0, InputStream arg1, long arg2)
			throws SQLException {
		this.underlying.updateBlob(arg0, arg1, arg2);
	}

	@Override
	public void updateBlob(String arg0, InputStream arg1, long arg2)
			throws SQLException {
		this.underlying.updateBlob(arg0, arg1, arg2);
	}

	@Override
	public void updateBoolean(int columnIndex, boolean x) throws SQLException {
		this.underlying.updateBoolean(columnIndex, x);
	}

	@Override
	public void updateBoolean(String columnName, boolean x) throws SQLException {
		this.underlying.updateBoolean(columnName, x);
	}

	@Override
	public void updateByte(int columnIndex, byte x) throws SQLException {
		this.underlying.updateByte(columnIndex, x);
	}

	@Override
	public void updateByte(String columnName, byte x) throws SQLException {
		this.underlying.updateByte(columnName, x);
	}

	@Override
	public void updateBytes(int columnIndex, byte[] x) throws SQLException {
		this.underlying.updateBytes(columnIndex, x);
	}

	@Override
	public void updateBytes(String columnName, byte[] x) throws SQLException {
		this.underlying.updateBytes(columnName, x);
	}

	@Override
	public void updateCharacterStream(int arg0, Reader arg1)
			throws SQLException {
		this.underlying.updateCharacterStream(arg0, arg1);
	}

	@Override
	public void updateCharacterStream(String arg0, Reader arg1)
			throws SQLException {
		this.underlying.updateCharacterStream(arg0, arg1);
	}

	@Override
	public void updateCharacterStream(int columnIndex, Reader x, int length)
			throws SQLException {
		this.underlying.updateCharacterStream(columnIndex, x,length);
	}

	@Override
	public void updateCharacterStream(String columnName, Reader reader,
			int length) throws SQLException {
		this.underlying.updateCharacterStream(columnName, reader, length);
	}

	@Override
	public void updateCharacterStream(int arg0, Reader arg1, long arg2)
			throws SQLException {
		this.underlying.updateCharacterStream(arg0, arg1,arg2);
	}

	@Override
	public void updateCharacterStream(String arg0, Reader arg1, long arg2)
			throws SQLException {
		this.underlying.updateCharacterStream(arg0, arg1,arg2);
	}

	@Override
	public void updateClob(int columnIndex, Clob x) throws SQLException {
		this.underlying.updateClob(columnIndex, x);
	}

	@Override
	public void updateClob(String columnName, Clob x) throws SQLException {
		this.underlying.updateClob(columnName, x);
	}

	@Override
	public void updateClob(int arg0, Reader arg1) throws SQLException {
		this.underlying.updateClob(arg0, arg1);
	}

	@Override
	public void updateClob(String arg0, Reader arg1) throws SQLException {
		this.underlying.updateClob(arg0, arg1);
	}

	@Override
	public void updateClob(int arg0, Reader arg1, long arg2)
			throws SQLException {
		this.underlying.updateClob(arg0, arg1, arg2);
	}

	@Override
	public void updateClob(String arg0, Reader arg1, long arg2)
			throws SQLException {
		this.underlying.updateClob(arg0, arg1, arg2);
	}

	@Override
	public void updateDate(int columnIndex, Date x) throws SQLException {
		this.underlying.updateDate(columnIndex, x);
	}

	@Override
	public void updateDate(String columnName, Date x) throws SQLException {
		this.underlying.updateDate(columnName, x);
	}

	@Override
	public void updateDouble(int columnIndex, double x) throws SQLException {
		this.underlying.updateDouble(columnIndex, x);
	}

	@Override
	public void updateDouble(String columnName, double x) throws SQLException {
		this.underlying.updateDouble(columnName, x);
	}

	@Override
	public void updateFloat(int columnIndex, float x) throws SQLException {
		this.underlying.updateFloat(columnIndex, x);
	}

	@Override
	public void updateFloat(String columnName, float x) throws SQLException {
		this.underlying.updateFloat(columnName, x);
	}

	@Override
	public void updateInt(int columnIndex, int x) throws SQLException {
		this.underlying.updateInt(columnIndex, x);
	}

	@Override
	public void updateInt(String columnName, int x) throws SQLException {
		this.underlying.updateInt(columnName, x);
	}

	@Override
	public void updateLong(int columnIndex, long x) throws SQLException {
		this.underlying.updateLong(columnIndex, x);
	}

	@Override
	public void updateLong(String columnName, long x) throws SQLException {
		this.underlying.updateLong(columnName, x);
	}

	@Override
	public void updateNCharacterStream(int arg0, Reader arg1)
			throws SQLException {
		this.underlying.updateNCharacterStream(arg0, arg1);
	}

	@Override
	public void updateNCharacterStream(String arg0, Reader arg1)
			throws SQLException {
		this.underlying.updateNCharacterStream(arg0, arg1);
	}

	@Override
	public void updateNCharacterStream(int arg0, Reader arg1, long arg2)
			throws SQLException {
		this.underlying.updateNCharacterStream(arg0, arg1, arg2);
	}

	@Override
	public void updateNCharacterStream(String arg0, Reader arg1, long arg2)
			throws SQLException {
		this.underlying.updateNCharacterStream(arg0, arg1, arg2);
	}

	@Override
	public void updateNClob(int arg0, NClob arg1) throws SQLException {
		this.underlying.updateNClob(arg0, arg1);
	}

	@Override
	public void updateNClob(String arg0, NClob arg1) throws SQLException {
		this.underlying.updateNClob(arg0, arg1);
	}

	@Override
	public void updateNClob(int arg0, Reader arg1) throws SQLException {
		this.underlying.updateNClob(arg0, arg1);
	}

	@Override
	public void updateNClob(String arg0, Reader arg1) throws SQLException {
		this.underlying.updateNClob(arg0, arg1);
	}

	@Override
	public void updateNClob(int arg0, Reader arg1, long arg2)
			throws SQLException {
		this.underlying.updateNClob(arg0, arg1, arg2);
	}

	@Override
	public void updateNClob(String arg0, Reader arg1, long arg2)
			throws SQLException {
		this.underlying.updateNClob(arg0, arg1, arg2);
	}

	@Override
	public void updateNString(int arg0, String arg1) throws SQLException {
		this.underlying.updateNString(arg0, arg1);
	}

	@Override
	public void updateNString(String arg0, String arg1) throws SQLException {
		this.underlying.updateNString(arg0, arg1);
	}

	@Override
	public void updateNull(int columnIndex) throws SQLException {
		this.underlying.updateNull(columnIndex);
	}

	@Override
	public void updateNull(String columnName) throws SQLException {
		this.underlying.updateNull(columnName);
	}

	@Override
	public void updateObject(int columnIndex, Object x) throws SQLException {
		this.underlying.updateObject(columnIndex, x);
	}

	@Override
	public void updateObject(String columnName, Object x) throws SQLException {
		this.underlying.updateObject(columnName, x);
	}

	@Override
	public void updateObject(int columnIndex, Object x, int scale)
			throws SQLException {
		this.underlying.updateObject(columnIndex, x, scale);
	}

	@Override
	public void updateObject(String columnName, Object x, int scale)
			throws SQLException {
		this.underlying.updateObject(columnName, x, scale);
	}

	@Override
	public void updateRef(int columnIndex, Ref x) throws SQLException {
		this.underlying.updateRef(columnIndex, x);
	}

	@Override
	public void updateRef(String columnName, Ref x) throws SQLException {
		this.underlying.updateRef(columnName, x);
	}

	@Override
	public void updateRow() throws SQLException {
		this.underlying.updateRow();
	}

	@Override
	public void updateRowId(int arg0, RowId arg1) throws SQLException {
		this.underlying.updateRowId(arg0, arg1);
	}

	@Override
	public void updateRowId(String arg0, RowId arg1) throws SQLException {
		this.underlying.updateRowId(arg0, arg1);
	}

	@Override
	public void updateSQLXML(int arg0, SQLXML arg1) throws SQLException {
		this.underlying.updateSQLXML(arg0, arg1);
	}

	@Override
	public void updateSQLXML(String arg0, SQLXML arg1) throws SQLException {
		this.underlying.updateSQLXML(arg0, arg1);
	}

	@Override
	public void updateShort(int columnIndex, short x) throws SQLException {
		this.underlying.updateShort(columnIndex, x);
	}

	@Override
	public void updateShort(String columnName, short x) throws SQLException {
		this.underlying.updateShort(columnName, x);
	}

	@Override
	public void updateString(int columnIndex, String x) throws SQLException {
		this.underlying.updateString(columnIndex, x);
	}

	@Override
	public void updateString(String columnName, String x) throws SQLException {
		this.underlying.updateString(columnName, x);
	}

	@Override
	public void updateTime(int columnIndex, Time x) throws SQLException {
		this.underlying.updateTime(columnIndex, x);
	}

	@Override
	public void updateTime(String columnName, Time x) throws SQLException {
		this.underlying.updateTime(columnName, x);
	}

	@Override
	public void updateTimestamp(int columnIndex, Timestamp x)
			throws SQLException {
		this.underlying.updateTimestamp(columnIndex, x);
	}

	@Override
	public void updateTimestamp(String columnName, Timestamp x)
			throws SQLException {
		this.underlying.updateTimestamp(columnName, x);
	}

	@Override
	public boolean wasNull() throws SQLException {
		return this.underlying.wasNull();
	}

	@Override
	public boolean isWrapperFor(Class<?> iface) throws SQLException {
		return this.underlying.isWrapperFor(iface);
	}

	@Override
	public <T> T unwrap(Class<T> iface) throws SQLException {
		return this.underlying.unwrap(iface);
	}

}
